home *** CD-ROM | disk | FTP | other *** search
/ Amiga Plus Special 26 / AMIGAplus Sonderheft 26 (2000)(Falke)(DE)(Track 1 of 2)[!].iso / Tools / GFX-Viewer / Animviewer / mpegvideo_datatype / ham / HAMView.c < prev    next >
C/C++ Source or Header  |  1999-03-29  |  29KB  |  1,125 lines
  1. /*
  2. **    PhotoworX - Ein Softwarepaket zur Bearbeitung
  3. **                  von Kodak Photo-CDs
  4. **
  5. **    Copyright © 1993-1995 by Corporate Media GmbH
  6. **    Geschrieben von Olaf Barthel
  7. */
  8.  
  9. #include <intuition/intuitionbase.h>
  10. #include <graphics/gfxbase.h>
  11. #include <exec/execbase.h>
  12. #include <exec/memory.h>
  13.  
  14. #include <clib/intuition_protos.h>
  15. #include <clib/graphics_protos.h>
  16. #include <clib/utility_protos.h>
  17. #include <clib/exec_protos.h>
  18. #include <clib/macros.h>
  19.  
  20. #include <pragmas/intuition_pragmas.h>
  21. #include <pragmas/graphics_pragmas.h>
  22. #include <pragmas/utility_pragmas.h>
  23. #include <pragmas/exec_sysbase_pragmas.h>
  24.  
  25. #define USE_BUILTIN_MATH
  26.  
  27. #include <string.h>
  28.  
  29. #define    LIB_CODE
  30. #include "viewer.h"
  31. #undef    LIB_CODE
  32.  
  33. enum    {    MODE_HAM6,MODE_HAM8,MODE_MAX };
  34.  
  35. #define SPREAD(v)    ((ULONG)(v) << 24 | (ULONG)(v) << 16 | (ULONG)(v) << 8 | (v))
  36.  
  37. #define PORTMASK(p)    (1L << ((struct MsgPort *)p) -> mp_SigBit)
  38.  
  39. struct ExecBase        *SysBase;
  40. struct IntuitionBase    *IntuitionBase;
  41. struct GfxBase        *GfxBase;
  42. struct Library        *UtilityBase;
  43.  
  44. struct SignalSemaphore     Semaphore;
  45.  
  46. LONG ShadeTable[] =
  47. {
  48.     16 * 16 * 16,
  49.     64 * 64 * 64,
  50.     0
  51. };
  52.  
  53. struct VL_ModeTable ModeTable =
  54. {
  55.     "Hold-and-modify Display",
  56.     ShadeTable
  57. };
  58.  
  59. VOID (* __asm WriteLine)(register __a0 struct RastPort *RPort,register __d0 LONG Column,register __d1 LONG Line,register __d2 LONG Width,register __a2 APTR Array,register __a1 struct RastPort *Temp);
  60.  
  61. extern WORD __asm        Luminance(register __d0 WORD Red,register __d1 WORD Green,register __d2 WORD Blue);
  62. extern VOID __asm        CreateHAM6Line(register __a0 UBYTE *R,register __a1 UBYTE *G,register __a2 UBYTE *B,register __a3 UBYTE *Line,register __d3 LONG PixelPlus,register __d4 WORD Width);
  63. extern VOID __asm        CreateHAM8Line(register __a0 UBYTE *R,register __a1 UBYTE *G,register __a2 UBYTE *B,register __a3 UBYTE *Line,register __d3 LONG PixelPlus,register __d4 WORD Width);
  64.  
  65. LONG __saveds __asm        __UserLibInit(register __a6 struct Library *LibBase);
  66. VOID __saveds __asm        __UserLibCleanup(register __a6 struct Library *LibBase);
  67.  
  68. struct VL_ModeTable * __saveds __asm    VL_GetModeTable(VOID);
  69. LONG __saveds __asm            VL_OpenView(register __a0 struct VL_ViewHandle *Handle);
  70. VOID __saveds __asm            VL_CloseView(register __a0 struct VL_ViewHandle *Handle);
  71. LONG __saveds __asm            VL_MoveView(register __a0 struct VL_ViewHandle *Handle,register __d0 LONG X,register __d1 LONG Y);
  72. ULONG __saveds __asm            VL_TranslateIDCMP(register __a0 struct VL_ViewHandle *Handle,register __d0 ULONG IDCMP);
  73.  
  74. STATIC VOID __asm
  75. PositionLine8(register __a0 struct RastPort *RPort,register __d0 LONG Column,register __d1 LONG Line,register __d2 LONG Width,register __a2 APTR Array,register __a1 struct RastPort *Temp)
  76. {
  77.     #pragma libcall GfxBase WritePixelLine8 306 9A210806
  78.  
  79.     WritePixelLine8(RPort,Column,Line,Width,Array,Temp);
  80. }
  81.  
  82. STATIC VOID __asm
  83. PositionChunkyPixels(register __a0 struct RastPort *RPort,register __d0 LONG Column,register __d1 LONG Line,register __d2 LONG Width,register __a2 APTR Array,register __a1 struct RastPort *Temp)
  84. {
  85.     #pragma libcall GfxBase WriteChunkyPixels 420 4a3210807
  86.  
  87.     WriteChunkyPixels(RPort,Column,Line,Column + Width - 1,Line,Array,(Width + 15) & ~15);
  88. }
  89.  
  90. STATIC VOID
  91. DeleteBitMap(struct BitMap *BitMap)
  92. {
  93.     if(GfxBase -> LibNode . lib_Version >= 39)
  94.         FreeBitMap(BitMap);
  95.     else
  96.     {
  97.         LONG i;
  98.  
  99.         for(i = 0 ; i < BitMap -> Depth ; i++)
  100.         {
  101.             if(BitMap -> Planes[i])
  102.                 FreeVec(BitMap -> Planes[i]);
  103.         }
  104.  
  105.         FreeVec(BitMap);
  106.     }
  107. }
  108.  
  109. STATIC struct BitMap *
  110. CreateBitMap(LONG Width,LONG Height,LONG Depth,ULONG Flags,struct BitMap *Friend)
  111. {
  112.     if(GfxBase -> LibNode . lib_Version >= 39)
  113.         return(AllocBitMap(Width,Height,Depth,Flags,Friend));
  114.     else
  115.     {
  116.         struct BitMap *BitMap;
  117.  
  118.         if(BitMap = (struct BitMap *)AllocVec(sizeof(struct BitMap),MEMF_ANY | MEMF_CLEAR))
  119.         {
  120.             LONG i,PageSize;
  121.  
  122.             InitBitMap(BitMap,Depth,Width,Height);
  123.  
  124.             PageSize = BitMap -> BytesPerRow * BitMap -> Rows;
  125.  
  126.             for(i = 0 ; i < BitMap -> Depth ; i++)
  127.             {
  128.                 if(!(BitMap -> Planes[i] = (PLANEPTR)AllocVec(PageSize,MEMF_CHIP)))
  129.                 {
  130.                     LONG j;
  131.  
  132.                     for(j = 0 ; j < i ; j++)
  133.                         FreeVec(BitMap -> Planes[j]);
  134.  
  135.                     FreeVec(BitMap);
  136.  
  137.                     return(NULL);
  138.                 }
  139.             }
  140.         }
  141.  
  142.         return(BitMap);
  143.     }
  144. }
  145.  
  146. STATIC VOID
  147. DeleteTempLine(UBYTE *Line)
  148. {
  149.     FreeVec(Line);
  150. }
  151.  
  152. STATIC UBYTE *
  153. CreateTempLine(LONG Width,LONG Height)
  154. {
  155.     return((UBYTE *)AllocVec(((Width + 15) & ~15) * Height,MEMF_ANY));
  156. }
  157.  
  158. STATIC VOID
  159. DeleteTempRPort(struct RastPort *Temp)
  160. {
  161.     DeleteBitMap(Temp -> BitMap);
  162.  
  163.     FreeVec(Temp);
  164. }
  165.  
  166. STATIC struct RastPort *
  167. CreateTempRPort(struct RastPort *Source)
  168. {
  169.     struct RastPort *Temp;
  170.  
  171.     if(Temp = (struct RastPort *)AllocVec(sizeof(struct RastPort),MEMF_ANY))
  172.     {
  173.         LONG Width,Depth;
  174.  
  175.         CopyMem(Source,Temp,sizeof(struct RastPort));
  176.  
  177.         Temp -> Layer = NULL;
  178.  
  179.         if(GfxBase -> LibNode . lib_Version >= 39)
  180.         {
  181.             Width = GetBitMapAttr(Source -> BitMap,BMA_WIDTH);
  182.             Depth = GetBitMapAttr(Source -> BitMap,BMA_DEPTH);
  183.         }
  184.         else
  185.         {
  186.             Width = Source -> BitMap -> BytesPerRow * 8;
  187.             Depth = Source -> BitMap -> Depth;
  188.         }
  189.  
  190.         if(Temp -> BitMap = CreateBitMap(Width,1,Depth,NULL,Source -> BitMap))
  191.             return(Temp);
  192.         else
  193.             FreeVec(Temp);
  194.     }
  195.  
  196.     return(NULL);
  197. }
  198.  
  199. STATIC VOID
  200. CloseWindowSafely(struct Window *Window)
  201. {
  202.     Forbid();
  203.  
  204.     if(Window -> UserPort)
  205.     {
  206.         struct IntuiMessage    *IntuiMessage;
  207.         struct Node        *Successor;
  208.  
  209.         SetSignal(0,1L << Window -> UserPort -> mp_SigBit);
  210.  
  211.         IntuiMessage = (struct IntuiMessage *)Window -> UserPort -> mp_MsgList . lh_Head;
  212.  
  213.         while(Successor = IntuiMessage -> ExecMessage . mn_Node . ln_Succ)
  214.         {
  215.             if(IntuiMessage -> IDCMPWindow == Window)
  216.             {
  217.                 Remove(IntuiMessage);
  218.  
  219.                 ReplyMsg((struct Message *)IntuiMessage);
  220.             }
  221.  
  222.             IntuiMessage = (struct IntuiMessage *)Successor;
  223.         }
  224.  
  225.         Window -> UserPort = NULL;
  226.     }
  227.  
  228.     ModifyIDCMP(Window,NULL);
  229.  
  230.     Permit();
  231.  
  232.     CloseWindow(Window);
  233. }
  234.  
  235. LONG __saveds __asm __UserLibInit(register __a6 struct Library *LibBase)
  236. {
  237.     SysBase = *(struct ExecBase **)4;
  238.  
  239.     if(IntuitionBase = (struct IntuitionBase *)OpenLibrary("intuition.library",37))
  240.     {
  241.         if(GfxBase = (struct GfxBase *)OpenLibrary("graphics.library",37))
  242.         {
  243.             if(UtilityBase = OpenLibrary("utility.library",37))
  244.             {
  245.                 if(ModeNotAvailable(DEFAULT_MONITOR_ID | HIRESHAMLACE_KEY))
  246.                     ShadeTable[1] = 0;
  247.  
  248.                 if(GfxBase -> LibNode . lib_Version >= 40 && GfxBase -> ChunkyToPlanarPtr)
  249.                     WriteLine = PositionChunkyPixels;
  250.                 else
  251.                     WriteLine = PositionLine8;
  252.  
  253.                 InitSemaphore(&Semaphore);
  254.  
  255.                 return(NULL);
  256.             }
  257.  
  258.             CloseLibrary(GfxBase);
  259.  
  260.             GfxBase = NULL;
  261.         }
  262.  
  263.         CloseLibrary(IntuitionBase);
  264.  
  265.         IntuitionBase = NULL;
  266.     }
  267.  
  268.     return(1);
  269. }
  270.  
  271. VOID __saveds __asm __UserLibCleanup(register __a6 struct Library *LibBase)
  272. {
  273.     if(IntuitionBase)
  274.     {
  275.         CloseLibrary(IntuitionBase);
  276.  
  277.         IntuitionBase = NULL;
  278.     }
  279.  
  280.     if(GfxBase)
  281.     {
  282.         CloseLibrary(GfxBase);
  283.  
  284.         GfxBase = NULL;
  285.     }
  286.  
  287.     if(UtilityBase)
  288.     {
  289.         CloseLibrary(UtilityBase);
  290.  
  291.         UtilityBase = NULL;
  292.     }
  293. }
  294.  
  295. struct VL_ModeTable * __saveds __asm
  296. VL_GetModeTable()
  297. {
  298.     return(&ModeTable);
  299. }
  300.  
  301. LONG __saveds __asm
  302. VL_OpenView(register __a0 struct VL_ViewHandle *Handle)
  303. {
  304.     LONG Error = 0;
  305.  
  306.     if(Handle)
  307.     {
  308.         if(Handle -> vl_Mode < 0 || Handle -> vl_Mode >= MODE_MAX)
  309.             Error = VL_ERROR_INVALID_MODE;
  310.         else
  311.         {
  312.             if(Handle -> vl_Screen = OpenScreenTags(NULL,
  313.                 SA_Overscan,    OSCAN_STANDARD,
  314.                 SA_Depth,    Handle -> vl_Mode == MODE_HAM6 ? 6 : 8,
  315.                 SA_DisplayID,    Handle -> vl_Mode == MODE_HAM6 ? DEFAULT_MONITOR_ID | HAM_KEY : DEFAULT_MONITOR_ID | HIRESHAMLACE_KEY,
  316.                 SA_Quiet,    TRUE,
  317.                 SA_ShowTitle,    FALSE,
  318.                 SA_Behind,    TRUE,
  319.                 SA_Interleaved,    TRUE,
  320.                 SA_BackFill,    LAYERS_NOBACKFILL,
  321.             TAG_DONE))
  322.             {
  323.                 if(Handle -> vl_Window = OpenWindowTags(NULL,
  324.                     WA_Left,        0,
  325.                     WA_Top,            0,
  326.                     WA_Width,        Handle -> vl_Screen -> Width,
  327.                     WA_Height,        Handle -> vl_Screen -> Height,
  328.                     WA_Borderless,        TRUE,
  329.                     WA_Backdrop,        TRUE,
  330.                     WA_RMBTrap,        TRUE,
  331.                     WA_Activate,        TRUE,
  332.                     WA_SimpleRefresh,    TRUE,
  333.                     WA_NoCareRefresh,    TRUE,
  334.                     WA_CustomScreen,    Handle -> vl_Screen,
  335.                     WA_IDCMP,        Handle -> vl_MsgPort ? NULL : Handle -> vl_IDCMP,
  336.  
  337.                     IntuitionBase->LibNode.lib_Version >= 39 ? WA_BackFill : TAG_IGNORE, LAYERS_NOBACKFILL,
  338.                 TAG_DONE))
  339.                 {
  340.                     struct RastPort *TempRPort,*RPort = &Handle -> vl_Screen -> RastPort;
  341.  
  342.                     SetRast(RPort,0);
  343.  
  344.                     if(TempRPort = CreateTempRPort(RPort))
  345.                     {
  346.                         UBYTE *TempLine;
  347.  
  348.                         if(TempLine = CreateTempLine(Handle -> vl_Screen -> Width,1))
  349.                         {
  350.                             STATIC UWORD __chip BlankPointer[6];
  351.  
  352.                             SetPointer(Handle -> vl_Window,BlankPointer,1,16,0,0);
  353.  
  354.                             if(Handle -> vl_MsgPort)
  355.                             {
  356.                                 Forbid();
  357.  
  358.                                 Handle -> vl_Window -> UserPort = Handle -> vl_MsgPort;
  359.  
  360.                                 if(!ModifyIDCMP(Handle -> vl_Window,Handle -> vl_IDCMP))
  361.                                 {
  362.                                     Permit();
  363.  
  364.                                     CloseWindowSafely(Handle -> vl_Window);
  365.  
  366.                                     Handle -> vl_Window = NULL;
  367.                                 }
  368.                                 else
  369.                                     Permit();
  370.                             }
  371.  
  372.                             if(Handle -> vl_Window)
  373.                             {
  374.                                 LONG i;
  375.  
  376.                                 ObtainSemaphore(&Semaphore);
  377.  
  378.                                 Handle -> vl_X        = 0;
  379.                                 Handle -> vl_Y        = 0;
  380.                                 Handle -> vl_VisibleX    = min(Handle -> vl_Width,Handle -> vl_Screen -> Width);
  381.                                 Handle -> vl_VisibleY    = min(Handle -> vl_Height,Handle -> vl_Screen -> Height);
  382.                                 Handle -> vl_MaxX    = (Handle -> vl_Width <= Handle -> vl_VisibleX) ? 0 : Handle -> vl_Width - Handle -> vl_VisibleX;
  383.                                 Handle -> vl_MaxY    = (Handle -> vl_Height <= Handle -> vl_VisibleY) ? 0 : Handle -> vl_Height - Handle -> vl_VisibleY;
  384.  
  385.                                 if(Handle -> vl_Mode == MODE_HAM6)
  386.                                 {
  387.                                     for(i = 0 ; i < 16 ; i++)
  388.                                         SetRGB4(&Handle -> vl_Screen -> ViewPort,i,i,i,i);
  389.                                 }
  390.                                 else
  391.                                 {
  392.                                     ULONG Value;
  393.  
  394.                                     for(i = 0 ; i < 64 ; i++)
  395.                                     {
  396.                                         Value = (255 * i) / 63;
  397.  
  398.                                         SetRGB32(&Handle -> vl_Screen -> ViewPort,i,SPREAD(Value),SPREAD(Value),SPREAD(Value));
  399.                                     }
  400.                                 }
  401.  
  402.                                 Handle -> vl_UserPort = Handle -> vl_Window -> UserPort;
  403.  
  404.                                 ActivateWindow(Handle -> vl_Window);
  405.  
  406.                                 ScreenToFront(Handle -> vl_Screen);
  407.  
  408.                                 Handle -> vl_ClientData[0] = TempRPort;
  409.                                 Handle -> vl_ClientData[1] = TempLine;
  410.  
  411.                                 if(Handle -> vl_Mode == MODE_HAM6)
  412.                                 {
  413.                                     LONG    Width    = Handle -> vl_Width,
  414.                                         Height = Handle -> vl_Height,
  415.                                         j;
  416.                                     UBYTE    *RData    = Handle -> vl_RData,
  417.                                         *GData    = Handle -> vl_GData,
  418.                                         *BData    = Handle -> vl_BData;
  419.  
  420.                                     if(Width > Handle -> vl_Screen -> Width)
  421.                                         Width = Handle -> vl_Screen -> Width;
  422.  
  423.                                     if(Height > Handle -> vl_Screen -> Height)
  424.                                         Height = Handle -> vl_Screen -> Height;
  425.  
  426.                                     if(Handle -> vl_Colour)
  427.                                     {
  428.                                         for(i = 0 ; i < Height ; i++)
  429.                                         {
  430.                                             CreateHAM6Line(RData,GData,BData,TempLine,Handle -> vl_PixelPlus,Width);
  431.  
  432.                                             (*WriteLine)(RPort,0,i,Width,TempLine,TempRPort);
  433.  
  434.                                             RData += Handle -> vl_LinePlus;
  435.                                             GData += Handle -> vl_LinePlus;
  436.                                             BData += Handle -> vl_LinePlus;
  437.                                         }
  438.                                     }
  439.                                     else
  440.                                     {
  441.                                         for(i = 0 ; i < Height ; i++)
  442.                                         {
  443.                                             register UBYTE    *R = RData,
  444.                                                     *G = GData,
  445.                                                     *B = BData;
  446.  
  447.                                             for(j = 0 ; j < Width ; j++)
  448.                                             {
  449.                                                 TempLine[j] = Luminance(*R,*G,*B) >> 4;
  450.  
  451.                                                 R += Handle -> vl_PixelPlus;
  452.                                                 G += Handle -> vl_PixelPlus;
  453.                                                 B += Handle -> vl_PixelPlus;
  454.                                             }
  455.  
  456.                                             (*WriteLine)(RPort,0,i,Width,TempLine,TempRPort);
  457.  
  458.                                             RData += Handle -> vl_LinePlus;
  459.                                             GData += Handle -> vl_LinePlus;
  460.                                             BData += Handle -> vl_LinePlus;
  461.                                         }
  462.                                     }
  463.                                 }
  464.                                 else
  465.                                 {
  466.                                     LONG    Width    = Handle -> vl_Width,
  467.                                         Height    = Handle -> vl_Height,
  468.                                         j;
  469.                                     UBYTE    *RData    = Handle -> vl_RData,
  470.                                         *GData    = Handle -> vl_GData,
  471.                                         *BData    = Handle -> vl_BData;
  472.  
  473.                                     if(Width > Handle -> vl_Screen -> Width)
  474.                                         Width = Handle -> vl_Screen -> Width;
  475.  
  476.                                     if(Height > Handle -> vl_Screen -> Height)
  477.                                         Height = Handle -> vl_Screen -> Height;
  478.  
  479.                                     if(Handle -> vl_Colour)
  480.                                     {
  481.                                         for(i = 0 ; i < Height ; i++)
  482.                                         {
  483.                                             CreateHAM8Line(RData,GData,BData,TempLine,Handle -> vl_PixelPlus,Width);
  484.  
  485.                                             (*WriteLine)(RPort,0,i,Width,TempLine,TempRPort);
  486.  
  487.                                             RData += Handle -> vl_LinePlus;
  488.                                             GData += Handle -> vl_LinePlus;
  489.                                             BData += Handle -> vl_LinePlus;
  490.                                         }
  491.                                     }
  492.                                     else
  493.                                     {
  494.                                         for(i = 0 ; i < Height ; i++)
  495.                                         {
  496.                                             register UBYTE    *R = RData,
  497.                                                     *G = GData,
  498.                                                     *B = BData;
  499.  
  500.                                             for(j = 0 ; j < Width ; j++)
  501.                                             {
  502.                                                 TempLine[j] = Luminance(*R,*G,*B) >> 2;
  503.  
  504.                                                 R += Handle -> vl_PixelPlus;
  505.                                                 G += Handle -> vl_PixelPlus;
  506.                                                 B += Handle -> vl_PixelPlus;
  507.                                             }
  508.  
  509.                                             (*WriteLine)(RPort,0,i,Width,TempLine,TempRPort);
  510.  
  511.                                             RData += Handle -> vl_LinePlus;
  512.                                             GData += Handle -> vl_LinePlus;
  513.                                             BData += Handle -> vl_LinePlus;
  514.                                         }
  515.                                     }
  516.                                 }
  517.  
  518.                                 ReleaseSemaphore(&Semaphore);
  519.                             }
  520.                             else
  521.                                 Error = VL_ERROR_NO_WINDOW;
  522.                         }
  523.                         else
  524.                             Error = VL_ERROR_NO_MEMORY;
  525.                     }
  526.                     else
  527.                         Error = VL_ERROR_NO_MEMORY;
  528.                 }
  529.                 else
  530.                     Error = VL_ERROR_NO_WINDOW;
  531.             }
  532.             else
  533.                 Error = VL_ERROR_NO_SCREEN;
  534.         }
  535.     }
  536.     else
  537.         Error = VL_ERROR_INVALID_PARAMETERS;
  538.  
  539.     return(Error);
  540. }
  541.  
  542. VOID __saveds __asm
  543. VL_CloseView(register __a0 struct VL_ViewHandle *Handle)
  544. {
  545.     if(Handle -> vl_ClientData[0])
  546.     {
  547.         DeleteTempRPort(Handle -> vl_ClientData[0]);
  548.  
  549.         Handle -> vl_ClientData[0] = NULL;
  550.     }
  551.  
  552.     if(Handle -> vl_ClientData[1])
  553.     {
  554.         DeleteTempLine(Handle -> vl_ClientData[1]);
  555.  
  556.         Handle -> vl_ClientData[1] = NULL;
  557.     }
  558.  
  559.     if(Handle -> vl_Window)
  560.     {
  561.         ScreenToBack(Handle -> vl_Window -> WScreen);
  562.  
  563.         if(Handle -> vl_MsgPort)
  564.             CloseWindowSafely(Handle -> vl_Window);
  565.         else
  566.             CloseWindow(Handle -> vl_Window);
  567.  
  568.         Handle -> vl_Window = NULL;
  569.     }
  570.  
  571.     if(Handle -> vl_Screen)
  572.     {
  573.         CloseScreen(Handle -> vl_Screen);
  574.  
  575.         Handle -> vl_Screen = NULL;
  576.     }
  577. }
  578.  
  579. LONG __saveds __asm
  580. VL_MoveView(register __a0 struct VL_ViewHandle *Handle,register __d0 LONG X,register __d1 LONG Y)
  581. {
  582.     if(X > Handle -> vl_MaxX)
  583.         X = Handle -> vl_MaxX;
  584.     else
  585.     {
  586.         if(X < 0)
  587.             X = 0;
  588.     }
  589.  
  590.     if(Y > Handle -> vl_MaxY)
  591.         Y = Handle -> vl_MaxY;
  592.     else
  593.     {
  594.         if(Y < 0)
  595.             Y = 0;
  596.     }
  597.  
  598.     if(X != Handle -> vl_X || Y != Handle -> vl_Y)
  599.     {
  600.         struct RastPort *RPort = &Handle -> vl_Screen -> RastPort,*TempRPort = Handle -> vl_ClientData[0];
  601.         UBYTE *TempLine = Handle -> vl_ClientData[1];
  602.  
  603.         ObtainSemaphore(&Semaphore);
  604.  
  605.         if(Handle -> vl_X != X || Handle -> vl_Y != Y)
  606.         {
  607.             LONG From,Size,Src,Dst;
  608.  
  609.             if(X != Handle -> vl_X)
  610.             {
  611.                 if(X < Handle -> vl_X)
  612.                 {
  613.                     Size    = Handle -> vl_X - X;
  614.                     From    = 0;
  615.  
  616.                     Src    = 0;
  617.                     Dst    = Size;
  618.                 }
  619.                 else
  620.                 {
  621.                     Size    = X - Handle -> vl_X;
  622.                     From    = Handle -> vl_VisibleX - Size;
  623.  
  624.                     Src    = Size;
  625.                     Dst    = 0;
  626.                 }
  627.  
  628.                 if(Size > Handle -> vl_VisibleX)
  629.                 {
  630.                     Size = Handle -> vl_VisibleX;
  631.                     From = 0;
  632.                 }
  633.  
  634.                 if(Size < Handle -> vl_VisibleX)
  635.                 {
  636.                     LONG OldPri = SetTaskPri(SysBase -> ThisTask,127);
  637.  
  638.                     Forbid();
  639.  
  640.                     WaitTOF();
  641.  
  642.                     ClipBlit(RPort,Src,0,RPort,Dst,0,Handle -> vl_VisibleX - Size,Handle -> vl_Screen -> Height,0xC0);
  643.  
  644.                     Permit();
  645.  
  646.                     SetTaskPri(SysBase -> ThisTask,OldPri);
  647.                 }
  648.  
  649.                 if(!From && Size + 8 <= Handle -> vl_VisibleX)
  650.                     Size += 8;
  651.  
  652.                 if(Handle -> vl_Mode == MODE_HAM6)
  653.                 {
  654.                     LONG    x,y;
  655.                     UBYTE    *RData,*GData,*BData;
  656.  
  657.                     if(Handle -> vl_Colour)
  658.                     {
  659.                         if(From)
  660.                         {
  661.                             register LONG Size = 8;
  662.  
  663.                             RData    = Handle -> vl_RData + Handle -> vl_LinePlus * Y + Handle -> vl_PixelPlus * X;
  664.                             GData    = Handle -> vl_GData + Handle -> vl_LinePlus * Y + Handle -> vl_PixelPlus * X;
  665.                             BData    = Handle -> vl_BData + Handle -> vl_LinePlus * Y + Handle -> vl_PixelPlus * X;
  666.  
  667.                             for(y = 0 ; y < Handle -> vl_VisibleY ; y++)
  668.                             {
  669.                                 CreateHAM6Line(RData,GData,BData,TempLine,Handle -> vl_PixelPlus,Size);
  670.  
  671.                                 (*WriteLine)(RPort,0,y,Size,TempLine,TempRPort);
  672.  
  673.                                 RData += Handle -> vl_LinePlus;
  674.                                 GData += Handle -> vl_LinePlus;
  675.                                 BData += Handle -> vl_LinePlus;
  676.                             }
  677.                         }
  678.  
  679.                         if(From && Size + 16 <= Handle -> vl_VisibleX)
  680.                         {
  681.                             RData    = Handle -> vl_RData + Handle -> vl_LinePlus * Y + Handle -> vl_PixelPlus * (X + From);
  682.                             GData    = Handle -> vl_GData + Handle -> vl_LinePlus * Y + Handle -> vl_PixelPlus * (X + From);
  683.                             BData    = Handle -> vl_BData + Handle -> vl_LinePlus * Y + Handle -> vl_PixelPlus * (X + From);
  684.  
  685.                             RData -= 16 * Handle -> vl_PixelPlus;
  686.                             GData -= 16 * Handle -> vl_PixelPlus;
  687.                             BData -= 16 * Handle -> vl_PixelPlus;
  688.  
  689.                             for(y = 0 ; y < Handle -> vl_VisibleY ; y++)
  690.                             {
  691.                                 CreateHAM6Line(RData,GData,BData,TempLine,Handle -> vl_PixelPlus,Size + 16);
  692.  
  693.                                 (*WriteLine)(RPort,From,y,Size,TempLine + 16,TempRPort);
  694.  
  695.                                 RData += Handle -> vl_LinePlus;
  696.                                 GData += Handle -> vl_LinePlus;
  697.                                 BData += Handle -> vl_LinePlus;
  698.                             }
  699.                         }
  700.                         else
  701.                         {
  702.                             RData    = Handle -> vl_RData + Handle -> vl_LinePlus * Y + Handle -> vl_PixelPlus * (X + From);
  703.                             GData    = Handle -> vl_GData + Handle -> vl_LinePlus * Y + Handle -> vl_PixelPlus * (X + From);
  704.                             BData    = Handle -> vl_BData + Handle -> vl_LinePlus * Y + Handle -> vl_PixelPlus * (X + From);
  705.  
  706.                             for(y = 0 ; y < Handle -> vl_VisibleY ; y++)
  707.                             {
  708.                                 CreateHAM6Line(RData,GData,BData,TempLine,Handle -> vl_PixelPlus,Size);
  709.  
  710.                                 (*WriteLine)(RPort,From,y,Size,TempLine,TempRPort);
  711.  
  712.                                 RData += Handle -> vl_LinePlus;
  713.                                 GData += Handle -> vl_LinePlus;
  714.                                 BData += Handle -> vl_LinePlus;
  715.                             }
  716.                         }
  717.                     }
  718.                     else
  719.                     {
  720.                         if(From)
  721.                         {
  722.                             register LONG Size = 8;
  723.  
  724.                             RData    = Handle -> vl_RData + Handle -> vl_LinePlus * Y + Handle -> vl_PixelPlus * X;
  725.                             GData    = Handle -> vl_GData + Handle -> vl_LinePlus * Y + Handle -> vl_PixelPlus * X;
  726.                             BData    = Handle -> vl_BData + Handle -> vl_LinePlus * Y + Handle -> vl_PixelPlus * X;
  727.  
  728.                             for(y = 0 ; y < Handle -> vl_VisibleY ; y++)
  729.                             {
  730.                                 register UBYTE    *R = RData,
  731.                                         *G = GData,
  732.                                         *B = BData;
  733.  
  734.                                 for(x = 0 ; x < Size ; x++)
  735.                                 {
  736.                                     TempLine[x] = Luminance(*R,*G,*B) >> 4;
  737.  
  738.                                     R += Handle -> vl_PixelPlus;
  739.                                     G += Handle -> vl_PixelPlus;
  740.                                     B += Handle -> vl_PixelPlus;
  741.                                 }
  742.  
  743.                                 (*WriteLine)(RPort,0,y,Size,TempLine,TempRPort);
  744.  
  745.                                 RData += Handle -> vl_LinePlus;
  746.                                 GData += Handle -> vl_LinePlus;
  747.                                 BData += Handle -> vl_LinePlus;
  748.                             }
  749.                         }
  750.  
  751.                         if(From && Size + 16 <= Handle -> vl_VisibleX)
  752.                         {
  753.                             RData    = Handle -> vl_RData + Handle -> vl_LinePlus * Y + Handle -> vl_PixelPlus * (X + From);
  754.                             GData    = Handle -> vl_GData + Handle -> vl_LinePlus * Y + Handle -> vl_PixelPlus * (X + From);
  755.                             BData    = Handle -> vl_BData + Handle -> vl_LinePlus * Y + Handle -> vl_PixelPlus * (X + From);
  756.  
  757.                             RData -= 16 * Handle -> vl_PixelPlus;
  758.                             GData -= 16 * Handle -> vl_PixelPlus;
  759.                             BData -= 16 * Handle -> vl_PixelPlus;
  760.  
  761.                             for(y = 0 ; y < Handle -> vl_VisibleY ; y++)
  762.                             {
  763.                                 register UBYTE    *R = RData,
  764.                                         *G = GData,
  765.                                         *B = BData;
  766.  
  767.                                 for(x = 0 ; x < Size + 16 ; x++)
  768.                                 {
  769.                                     TempLine[x] = Luminance(*R,*G,*B) >> 4;
  770.  
  771.                                     R += Handle -> vl_PixelPlus;
  772.                                     G += Handle -> vl_PixelPlus;
  773.                                     B += Handle -> vl_PixelPlus;
  774.                                 }
  775.  
  776.                                 (*WriteLine)(RPort,From,y,Size,TempLine + 16,TempRPort);
  777.  
  778.                                 RData += Handle -> vl_LinePlus;
  779.                                 GData += Handle -> vl_LinePlus;
  780.                                 BData += Handle -> vl_LinePlus;
  781.                             }
  782.                         }
  783.                         else
  784.                         {
  785.                             RData    = Handle -> vl_RData + Handle -> vl_LinePlus * Y + Handle -> vl_PixelPlus * (X + From);
  786.                             GData    = Handle -> vl_GData + Handle -> vl_LinePlus * Y + Handle -> vl_PixelPlus * (X + From);
  787.                             BData    = Handle -> vl_BData + Handle -> vl_LinePlus * Y + Handle -> vl_PixelPlus * (X + From);
  788.  
  789.                             for(y = 0 ; y < Handle -> vl_VisibleY ; y++)
  790.                             {
  791.                                 register UBYTE    *R = RData,
  792.                                         *G = GData,
  793.                                         *B = BData;
  794.  
  795.                                 for(x = 0 ; x < Size ; x++)
  796.                                 {
  797.                                     TempLine[x] = Luminance(*R,*G,*B) >> 4;
  798.  
  799.                                     R += Handle -> vl_PixelPlus;
  800.                                     G += Handle -> vl_PixelPlus;
  801.                                     B += Handle -> vl_PixelPlus;
  802.                                 }
  803.  
  804.                                 (*WriteLine)(RPort,From,y,Size,TempLine,TempRPort);
  805.  
  806.                                 RData += Handle -> vl_LinePlus;
  807.                                 GData += Handle -> vl_LinePlus;
  808.                                 BData += Handle -> vl_LinePlus;
  809.                             }
  810.                         }
  811.                     }
  812.                 }
  813.                 else
  814.                 {
  815.                     LONG    x,y;
  816.                     UBYTE    *RData,*GData,*BData;
  817.  
  818.                     if(Handle -> vl_Colour)
  819.                     {
  820.                         if(From)
  821.                         {
  822.                             register LONG Size = 8;
  823.  
  824.                             RData    = Handle -> vl_RData + Handle -> vl_LinePlus * Y + Handle -> vl_PixelPlus * X;
  825.                             GData    = Handle -> vl_GData + Handle -> vl_LinePlus * Y + Handle -> vl_PixelPlus * X;
  826.                             BData    = Handle -> vl_BData + Handle -> vl_LinePlus * Y + Handle -> vl_PixelPlus * X;
  827.  
  828.                             for(y = 0 ; y < Handle -> vl_VisibleY ; y++)
  829.                             {
  830.                                 CreateHAM8Line(RData,GData,BData,TempLine,Handle -> vl_PixelPlus,Size);
  831.  
  832.                                 (*WriteLine)(RPort,0,y,Size,TempLine,TempRPort);
  833.  
  834.                                 RData += Handle -> vl_LinePlus;
  835.                                 GData += Handle -> vl_LinePlus;
  836.                                 BData += Handle -> vl_LinePlus;
  837.                             }
  838.                         }
  839.  
  840.                         if(From && Size + 16 <= Handle -> vl_VisibleX)
  841.                         {
  842.                             RData    = Handle -> vl_RData + Handle -> vl_LinePlus * Y + Handle -> vl_PixelPlus * (X + From);
  843.                             GData    = Handle -> vl_GData + Handle -> vl_LinePlus * Y + Handle -> vl_PixelPlus * (X + From);
  844.                             BData    = Handle -> vl_BData + Handle -> vl_LinePlus * Y + Handle -> vl_PixelPlus * (X + From);
  845.  
  846.                             RData -= 16 * Handle -> vl_PixelPlus;
  847.                             GData -= 16 * Handle -> vl_PixelPlus;
  848.                             BData -= 16 * Handle -> vl_PixelPlus;
  849.  
  850.                             for(y = 0 ; y < Handle -> vl_VisibleY ; y++)
  851.                             {
  852.                                 CreateHAM8Line(RData,GData,BData,TempLine,Handle -> vl_PixelPlus,Size + 16);
  853.  
  854.                                 (*WriteLine)(RPort,From,y,Size,TempLine + 16,TempRPort);
  855.  
  856.                                 RData += Handle -> vl_LinePlus;
  857.                                 GData += Handle -> vl_LinePlus;
  858.                                 BData += Handle -> vl_LinePlus;
  859.                             }
  860.                         }
  861.                         else
  862.                         {
  863.                             RData    = Handle -> vl_RData + Handle -> vl_LinePlus * Y + Handle -> vl_PixelPlus * (X + From);
  864.                             GData    = Handle -> vl_GData + Handle -> vl_LinePlus * Y + Handle -> vl_PixelPlus * (X + From);
  865.                             BData    = Handle -> vl_BData + Handle -> vl_LinePlus * Y + Handle -> vl_PixelPlus * (X + From);
  866.  
  867.                             for(y = 0 ; y < Handle -> vl_VisibleY ; y++)
  868.                             {
  869.                                 CreateHAM8Line(RData,GData,BData,TempLine,Handle -> vl_PixelPlus,Size);
  870.  
  871.                                 (*WriteLine)(RPort,From,y,Size,TempLine,TempRPort);
  872.  
  873.                                 RData += Handle -> vl_LinePlus;
  874.                                 GData += Handle -> vl_LinePlus;
  875.                                 BData += Handle -> vl_LinePlus;
  876.                             }
  877.                         }
  878.                     }
  879.                     else
  880.                     {
  881.                         if(From)
  882.                         {
  883.                             register LONG Size = 8;
  884.  
  885.                             RData    = Handle -> vl_RData + Handle -> vl_LinePlus * Y + Handle -> vl_PixelPlus * X;
  886.                             GData    = Handle -> vl_GData + Handle -> vl_LinePlus * Y + Handle -> vl_PixelPlus * X;
  887.                             BData    = Handle -> vl_BData + Handle -> vl_LinePlus * Y + Handle -> vl_PixelPlus * X;
  888.  
  889.                             for(y = 0 ; y < Handle -> vl_VisibleY ; y++)
  890.                             {
  891.                                 register UBYTE    *R = RData,
  892.                                         *G = GData,
  893.                                         *B = BData;
  894.  
  895.                                 for(x = 0 ; x < Size ; x++)
  896.                                 {
  897.                                     TempLine[x] = Luminance(*R,*G,*B) >> 2;
  898.  
  899.                                     R += Handle -> vl_PixelPlus;
  900.                                     G += Handle -> vl_PixelPlus;
  901.                                     B += Handle -> vl_PixelPlus;
  902.                                 }
  903.  
  904.                                 (*WriteLine)(RPort,0,y,Size,TempLine,TempRPort);
  905.  
  906.                                 RData += Handle -> vl_LinePlus;
  907.                                 GData += Handle -> vl_LinePlus;
  908.                                 BData += Handle -> vl_LinePlus;
  909.                             }
  910.                         }
  911.  
  912.                         if(From && Size + 16 <= Handle -> vl_VisibleX)
  913.                         {
  914.                             RData    = Handle -> vl_RData + Handle -> vl_LinePlus * Y + Handle -> vl_PixelPlus * (X + From);
  915.                             GData    = Handle -> vl_GData + Handle -> vl_LinePlus * Y + Handle -> vl_PixelPlus * (X + From);
  916.                             BData    = Handle -> vl_BData + Handle -> vl_LinePlus * Y + Handle -> vl_PixelPlus * (X + From);
  917.  
  918.                             RData -= 16 * Handle -> vl_PixelPlus;
  919.                             GData -= 16 * Handle -> vl_PixelPlus;
  920.                             BData -= 16 * Handle -> vl_PixelPlus;
  921.  
  922.                             for(y = 0 ; y < Handle -> vl_VisibleY ; y++)
  923.                             {
  924.                                 register UBYTE    *R = RData,
  925.                                         *G = GData,
  926.                                         *B = BData;
  927.  
  928.                                 for(x = 0 ; x < Size + 16 ; x++)
  929.                                 {
  930.                                     TempLine[x] = Luminance(*R,*G,*B) >> 2;
  931.  
  932.                                     R += Handle -> vl_PixelPlus;
  933.                                     G += Handle -> vl_PixelPlus;
  934.                                     B += Handle -> vl_PixelPlus;
  935.                                 }
  936.  
  937.                                 (*WriteLine)(RPort,From,y,Size,TempLine + 16,TempRPort);
  938.  
  939.                                 RData += Handle -> vl_LinePlus;
  940.                                 GData += Handle -> vl_LinePlus;
  941.                                 BData += Handle -> vl_LinePlus;
  942.                             }
  943.                         }
  944.                         else
  945.                         {
  946.                             RData    = Handle -> vl_RData + Handle -> vl_LinePlus * Y + Handle -> vl_PixelPlus * (X + From);
  947.                             GData    = Handle -> vl_GData + Handle -> vl_LinePlus * Y + Handle -> vl_PixelPlus * (X + From);
  948.                             BData    = Handle -> vl_BData + Handle -> vl_LinePlus * Y + Handle -> vl_PixelPlus * (X + From);
  949.  
  950.                             for(y = 0 ; y < Handle -> vl_VisibleY ; y++)
  951.                             {
  952.                                 register UBYTE    *R = RData,
  953.                                         *G = GData,
  954.                                         *B = BData;
  955.  
  956.                                 for(x = 0 ; x < Size ; x++)
  957.                                 {
  958.                                     TempLine[x] = Luminance(*R,*G,*B) >> 2;
  959.  
  960.                                     R += Handle -> vl_PixelPlus;
  961.                                     G += Handle -> vl_PixelPlus;
  962.                                     B += Handle -> vl_PixelPlus;
  963.                                 }
  964.  
  965.                                 (*WriteLine)(RPort,From,y,Size,TempLine,TempRPort);
  966.  
  967.                                 RData += Handle -> vl_LinePlus;
  968.                                 GData += Handle -> vl_LinePlus;
  969.                                 BData += Handle -> vl_LinePlus;
  970.                             }
  971.                         }
  972.                     }
  973.                 }
  974.             }
  975.  
  976.             if(Y != Handle -> vl_Y)
  977.             {
  978.                 if(Y < Handle -> vl_Y)
  979.                 {
  980.                     Size    = Handle -> vl_Y - Y;
  981.                     From    = 0;
  982.  
  983.                     Src    = 0;
  984.                     Dst    = Size;
  985.                 }
  986.                 else
  987.                 {
  988.                     Size    = Y - Handle -> vl_Y;
  989.                     From    = Handle -> vl_VisibleY - Size;
  990.  
  991.                     Src    = Size;
  992.                     Dst    = 0;
  993.                 }
  994.  
  995.                 if(Size > Handle -> vl_VisibleY)
  996.                 {
  997.                     Size = Handle -> vl_VisibleY;
  998.                     From = 0;
  999.                 }
  1000.  
  1001.                 if(Size < Handle -> vl_VisibleY)
  1002.                 {
  1003.                     LONG OldPri = SetTaskPri(SysBase -> ThisTask,127);
  1004.  
  1005.                     Forbid();
  1006.  
  1007.                     WaitTOF();
  1008.  
  1009.                     ClipBlit(RPort,0,Src,RPort,0,Dst,Handle -> vl_Screen -> Width,Handle -> vl_VisibleY - Size,0xC0);
  1010.  
  1011.                     Permit();
  1012.  
  1013.                     SetTaskPri(SysBase -> ThisTask,OldPri);
  1014.                 }
  1015.  
  1016.                 if(Handle -> vl_Mode == MODE_HAM6)
  1017.                 {
  1018.                     LONG    x,y;
  1019.                     UBYTE    *RData    = Handle -> vl_RData + Handle -> vl_LinePlus * (From + Y) + Handle -> vl_PixelPlus * X,
  1020.                         *GData    = Handle -> vl_GData + Handle -> vl_LinePlus * (From + Y) + Handle -> vl_PixelPlus * X,
  1021.                         *BData    = Handle -> vl_BData + Handle -> vl_LinePlus * (From + Y) + Handle -> vl_PixelPlus * X;
  1022.  
  1023.                     if(Handle -> vl_Colour)
  1024.                     {
  1025.                         for(y = 0 ; y < Size ; y++)
  1026.                         {
  1027.                             CreateHAM6Line(RData,GData,BData,TempLine,Handle -> vl_PixelPlus,Handle -> vl_VisibleX);
  1028.  
  1029.                             (*WriteLine)(RPort,0,From + y,Handle -> vl_VisibleX,TempLine,TempRPort);
  1030.  
  1031.                             RData += Handle -> vl_LinePlus;
  1032.                             GData += Handle -> vl_LinePlus;
  1033.                             BData += Handle -> vl_LinePlus;
  1034.                         }
  1035.                     }
  1036.                     else
  1037.                     {
  1038.                         for(y = 0 ; y < Size ; y++)
  1039.                         {
  1040.                             register UBYTE    *R = RData,
  1041.                                     *G = GData,
  1042.                                     *B = BData;
  1043.  
  1044.                             for(x = 0 ; x < Handle -> vl_VisibleX ; x++)
  1045.                             {
  1046.                                 TempLine[x] = Luminance(*R,*G,*B) >> 4;
  1047.  
  1048.                                 R += Handle -> vl_PixelPlus;
  1049.                                 G += Handle -> vl_PixelPlus;
  1050.                                 B += Handle -> vl_PixelPlus;
  1051.                             }
  1052.  
  1053.                             (*WriteLine)(RPort,0,From + y,Handle -> vl_VisibleX,TempLine,TempRPort);
  1054.  
  1055.                             RData += Handle -> vl_LinePlus;
  1056.                             GData += Handle -> vl_LinePlus;
  1057.                             BData += Handle -> vl_LinePlus;
  1058.                         }
  1059.                     }
  1060.                 }
  1061.                 else
  1062.                 {
  1063.                     LONG    x,y;
  1064.                     UBYTE    *RData    = Handle -> vl_RData + Handle -> vl_LinePlus * (From + Y) + Handle -> vl_PixelPlus * X,
  1065.                         *GData    = Handle -> vl_GData + Handle -> vl_LinePlus * (From + Y) + Handle -> vl_PixelPlus * X,
  1066.                         *BData    = Handle -> vl_BData + Handle -> vl_LinePlus * (From + Y) + Handle -> vl_PixelPlus * X;
  1067.  
  1068.                     if(Handle -> vl_Colour)
  1069.                     {
  1070.                         for(y = 0 ; y < Size ; y++)
  1071.                         {
  1072.                             CreateHAM8Line(RData,GData,BData,TempLine,Handle -> vl_PixelPlus,Handle -> vl_VisibleX);
  1073.  
  1074.                             (*WriteLine)(RPort,0,From + y,Handle -> vl_VisibleX,TempLine,TempRPort);
  1075.  
  1076.                             RData += Handle -> vl_LinePlus;
  1077.                             GData += Handle -> vl_LinePlus;
  1078.                             BData += Handle -> vl_LinePlus;
  1079.                         }
  1080.                     }
  1081.                     else
  1082.                     {
  1083.                         for(y = 0 ; y < Size ; y++)
  1084.                         {
  1085.                             register UBYTE    *R = RData,
  1086.                                     *G = GData,
  1087.                                     *B = BData;
  1088.  
  1089.                             for(x = 0 ; x < Handle -> vl_VisibleX ; x++)
  1090.                             {
  1091.                                 TempLine[x] = Luminance(*R,*G,*B) >> 2;
  1092.  
  1093.                                 R += Handle -> vl_PixelPlus;
  1094.                                 G += Handle -> vl_PixelPlus;
  1095.                                 B += Handle -> vl_PixelPlus;
  1096.                             }
  1097.  
  1098.                             (*WriteLine)(RPort,0,From + y,Handle -> vl_VisibleX,TempLine,TempRPort);
  1099.  
  1100.                             RData += Handle -> vl_LinePlus;
  1101.                             GData += Handle -> vl_LinePlus;
  1102.                             BData += Handle -> vl_LinePlus;
  1103.                         }
  1104.                     }
  1105.                 }
  1106.             }
  1107.         }
  1108.  
  1109.         ReleaseSemaphore(&Semaphore);
  1110.  
  1111.         Handle -> vl_X = X;
  1112.         Handle -> vl_Y = Y;
  1113.  
  1114.         return(TRUE);
  1115.     }
  1116.     else
  1117.         return(FALSE);
  1118. }
  1119.  
  1120. ULONG __saveds __asm
  1121. VL_TranslateIDCMP(register __a0 struct VL_ViewHandle *Handle,register __d0 ULONG IDCMP)
  1122. {
  1123.     return(IDCMP);
  1124. }
  1125.